perm filename RLL.MSC[RLL,DBL]1 blob
sn#600190 filedate 1981-07-20 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00004 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 List of all sentences
C00015 00003 Predicate Calculus Statements for Various RLL things
C00022 00004 What's in a Language?
C00027 ENDMK
C⊗;
List of all sentences
1. All purple mushrooms are poisonous.
2. Everybody loves somebody. {Two meanings}
3. Purple mushrooms have many attributes.
4. There are 23 purple mushrooms in the world.
5. Purple-mushroom-23 has been accessed 12 times.
6. The fact that a purple mushroom is purple is definitional.
7. The integers mod 5 form a group under addtion.
8. John gave Mary the book.
9. Apple-23 embodies the {theory | concept} pf apple. [is an examplar]
10. The color of all singleton sets is red.
↓ 11. The alleged theif hated the poor violinist.
12. Most elephants are grey.
↓ 13. John poured some of the liquid out of the bottle.
? 14. Tower of Hanoi
!Need:
4 forms of Isa:
(1) Standard - NON-Definitional
Expresses merely relation of set membership
(2) Existential - for ∃xεS
(3) Universal - for ∀xεS
New Any$SELF$Slots: DefinitionalSlots and AttributeSlots
This may require splitting many slots into multiple slots.
Conventions:
Any--- is the set of all ---s
Typical--- is a typical element of this set of ---
Every Typical--- unit has a slot InheritableSlots, which points to slots...
also DefinitionalSlots
If sεAny$SELF$Slot,
TypicalDog
TypicalExampleOf: AnyDog
InheritableSlots: (Parts, ..., MyWorth)
Parts: (4 legs, ...)
MyWorth: 45
MyWorthForInstance: 33
MyWorth
Isa: (Any$SELF$Slot)
StoredInTypAs: MyWorthForInstance
Now when Dog#53 is initialized,
its MyWorth value with be 33, NOT 45 (45 is worth of TypicalDog, qua unit.)
** Note ***
Slot1
SuperSlot: SSlot
means
1. Domain(Slot1)=Domain(SSlot)
2. ∀xεUnit. Slot1(x) ⊂ SSlot(x)
Typical1
SuperTypEx: STypical
means
TypicalExampleOf( Typical1 ) ⊂ TypicalExampleOf( STypical )
!1. All purple mushrooms are poisonous.
*** SOLN#1 ***
AnyMushroom
SubClass: AnyPurpleMushroom
AnyPurpleThing
SubClass: AnyPurpleMushroom
AnyPurpleMushroom
TypicalExample: TypicalPurpleMushroom
TypicalPurpleMushroom
Poisonous: T
InheritableSlots: (Poisonous)
*** SOLN#2 ***
AnyMushroom
UniversalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
InheritableSlots: (Poisonous)
Isa
Isa: {Slot}
SubSlots: {ExistentialIsa, UniversalIsa, StandardIsa}
UniversalIsa
Isa: {Slot}
SuperSlots: {Isa}
*** SOLN#3 ***
AnyMushroom
UniversalExamples: {x ... }
AnyPoisonousThing
StdExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
StdIsa: {AnyPosionousThing}
Color: Purple
DefinitionalSlots: {UniversalIsa, Color}
InheritableSlots: (Poisonous)
TROUBLE - unnatural!!!
*** SOLN#4 ***
AnyMushroom
SubClass: {x ... }
X
SuperClass: {AnyMushroom}
TypicalExample: TypicalX
DefinitionalSlots: {SuperClass, TypicalExample}
TypicalX
TypicalExampleOf: {X}
Poisonous: T
Color: Purple
? DefinitionalSlots: {?, Color}
InheritableSlots: (Poisonous)
!2a. Everybody loves somebody. ∀xεPerson ∃yεPerson. Loves(x,y)
AnyPerson
UniversalExamples: {x, y...}
x
UniversalIsa: {AnyPerson}
Loves: y
DefinitionalSlots: {UniversalIsa}
VariesThru: AnyPerson
y
ExistentialIsa: {AnyPerson}
LovedBy: x
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: x
!2b. Everybody loves somebody. ∃yεPerson ∀xεPerson. Loves(x,y)
*** SOLN#1 ***
AnyPerson
TypicalExample: TypicalPerson
UniversalExamples: {y, ...}
TypicalPerson
TypicalExampleOf: AnyPerson
Loves: y
y
ExistentialIsa: {AnyPerson}
LovesBy: TypicalPerson
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: NIL
*** SOLN#2 ***
AnyPerson
UniversalExamples: {x, y...}
x
UniversalIsa: {AnyPerson}
Loves: y
DefinitionalSlots: {UniversalIsa}
VariesThru: AnyPerson
y
ExistentialIsa: {AnyPerson}
LovesBy: TypicalPerson
DefinitionalSlots: {LovedBy, ExistentialIsa}
VariesWith: NIL
!3. Purple mushrooms have many attributes.
AnyMushroom
UniversalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
#Slots: Many
#Slots:
Isa: {Any$SELF$Slot}
!4. There are 23 purple mushrooms in the world.
AnyMushroom
Cardinality: 23
Cardinality
Isa: {Slot}
!5. Purple-mushroom-23 has been accessed 12 times.
AnyMushroom
Examples: {Purple-mushroom-23, ...}
Purple-mushroom-23
Isa: {AnyMushroom}
#Accesses: 12
#Accesses
Isa: {Any$SELF$Slot}
!6. The fact that a purple mushroom is purple is definitional.
AnyMushroom
UnverisalExamples: {x ... }
x
UniversalIsa: {AnyMushroom}
Color: Purple
Poisonous: T
DefinitionalSlots: {UniversalIsa, Color}
VariesThru: AnyMushroom
!7. Block1 and Block2 together form a blivit.
Block2 and Block3 together form a blivit.
Block1 and Block3 together form a blivit.
AnyBlivit
EssentialParts: {Whiggit, Whatever}
Examples: {Blivit-0, Blivit-32, Blivit-95 ...}
Blivit-0
Isa: (AnyBlivit)
Whiggit: Block1
Whatever: Block2
Blivit-32
Isa: (AnyBlivit)
Whiggit: Block2
Whatever: Block3
APartOf: Block3
Blivit-95
Isa: (AnyBlivit)
Whiggit: Block1
Whatever: Block3
Block1
Isa: {AnyBlock, AnyWhiggit}
WhiggitFor: (Blivit-0, Blivit-32)
APartOf: (Blivit-0, Blivit-32)
Block2
Isa: {AnyBlock, AnyWhiggit, AnyWhatever}
WhateverFor: (Blivit-0)
WhiggitFor: (Blivit-32)
APartOf: (Blivit-0, Blivit-32)
Block3
Isa: {AnyBlock, AnyWhatever}
WhiggitFor: (Blivit-32, Blivit-95)
APartOf: (Blivit-32, Blivit-95)
APartOf
Isa: (AnySlot)
SubSlots: (WhiggitFor, WhateverFor)
Whiggit
Isa: (AnySlot)
Inverse: WhiggitFor
Whatever
Isa: (AnySlot)
Inverse: WhateverFor
WhiggitFor
Isa: (AnySlot)
SuperSlots: (APartIn)
Inverse: Whiggit
WhateverFor
Isa: (AnySlot)
SuperSlots: (APartIn)
Inverse: Whatever
!8. John gave Mary the book.
AnyGivingEvent
Examples: {GE-41, ...}
GE-41
Giver: John
Recipient: Mary
Object: Book
John
GiverIn: GE-41
Mary
RecipientIn: GE-41
Book
ObjectIn: GE-41
GiverIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
RecipientIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
ObjectIn
Isa: {Slot}
SuperSlots: {ParticipatesIn}
!9. Apple-23 embodies the {theory | concept} pf apple. [is an examplar]
AnyApple
Examplar: Apple-23
Apple-23
ExamplarOf: AnyApple
Examplar
Isa: {Slot}
?
x = Examplar( S ) means:
1. x ε S
2. ∀yεS. ∀sεT. s(y) = s(x) most of the time.
where T = InheritableSlots(TypicalExample(S)).
[Rewording: ∀sεT. |{yεS | s(y) = s(x)}| ≥ 80% of |S| ]
!10. The color of all singleton sets is red.
AnySet
UniversalExamples: {x, ...}
x
UniversalIsa: {AnySet}
Cardinality: 1
DefinitionalSlots: {UniversalIsa, Cardinality}
Color: Red
!12. Most elephants are grey.
AnyElephant
TypicalExample: TypicalElephant
TypicalElephant
Propositions: {Prop-41, ...}
Grey
Isa: {AnyColor}
Propositions: {Prop-41, ...}
Prop-41
Relation: Color
Value: Grey
Modality: MostAre
FromUnit: TypicalElephant
Propositions
Isa: {Slot}
Datatype: ... (*P AnyProp) ...
AnyProp
TypicalExample: TypicalProp
TypicalProp
TypicalExampleOf: AnyProp
SensibleSlots: {Relation, Value, FromUnit, Modality, Tense, ...}
!-- Or --
AnyElephant
TypicalExample: TypicalElephant
TypicalElephant
Color: {(Prop Prop-41), ...}
Grey
Isa: {AnyColor}
ColorOf: {(Prop Prop-41), ...}
Prop-41
Relation: Color
Value: Grey
Modality: MostAre
FromUnit: TypicalElephant
!-- OR --
AnyElephant
UniversalExamples: {x, ...}
x
UniversalIsa: {AnyElephant}
QualifiedBy: Most
DefinitionalSlots: {UniversalIsa, NatureOfQualification}
Color: Grey
Most
?
--------------
AnyElephant
UniversalExamples: {x, ...}
AnyGreyThing
StdExamples: {x, ...}
x
UniversalIsa: {AnyElephant}
QualifiedBy: Most
DefinitionalSlots: {UniveralIsa, QualifiedBy}
StdIsa: {AnyGreyThing}
Isa: {AnyGreyThing, AnyElephant}
!14. Tower of Hanoi
??
Predicate Calculus Statements for Various RLL things
(15-Oct-80)
Typed logic
u, u-i, u0, u1, u2, ... Satisfy Unitp, i.e. represents Units
s, s-i, s0, s1, s2, ... Satisfy Slotp, i.e. represents Slots
(subtype of Units)
f, f-i, f0, f1, f2, ... represents Functions
l, l-i, l0, l1, l2, ... Satisfy LISTP, i.e. represents Lists
t, t-i, t0, t1, t2, ... represents Times
[ p's are used for pseudo-slots ]
LISP OVERHEAD:
[Note- this is essentially MEMB]
∀ v,l. v in l ≡ [ (l ≠ NIL) & ( v = CAR(l) ∨ v in CDR(l) )]
Slot Related Overhead:
∀ s. HighLevelDefn( s ) = GetValue( s,'HighLevelDefn )
∀ s. Format( s ) = GetValue( s,'Format )
∀ s. Defn( s ) = GetValue( s,'Defn )
∀ s. Domain( s ) = GetValue( s,'Domain )
∀ s. Range( s ) = GetValue( s,'Range )
∀ u,s. GetValue-1( u,s ) = GetValue( u,s )
∀ u,s. GetValue( u,s ) = OR( UA-GETVALUE( u,s ), APPLY( Defn( s ), u ) )
∀ p. Format( p ) = CAR( Range( p ))
∀ p,HLD. HighLevelDefn( p ) = HLD ⊃
Parse( HLD ) = LIST( Defn( p ), Range( p ), Domain( p ), ? ).
∀ u,p. GetValue-1( u,p ) = APPLY( Defn( p ),u ).
∀ u,p,v. InValue( u,p,v ) ≡
{ [ (Format( p ) ε {FSingleton} ) & v = GetValue-1( u,p ) ]
[ (Format( p ) ε {FSet, FList} ) & v in GetValue-1( u,p ) ] }
CONSISTENCY:
∀ u,s,v,v',t0,t1,t2.
[ UA-PUTVALUE( u,s,v )(t0) & [t0<t1<t2 ⊃ ¬UA-PUTVALUE( u,s,v' )(t1) ] ] ⊃
UA-GETVALUE( u,s )(t2) = v.
∀ u,s,v,v',t0,t1,t2.
[ PutValue( u,s,v )(t0) & [t0<t1<t2 ⊃ ¬PutValue( u,s,v' )(t1) ] ] ⊃
GetValue( u,s )(t2) = v.
∀ s1,s2. s2 = GetValue( s1,'Inverse ) ⊃
[∀ u,v. InValue( u1,s,v ) ⊃ [Unitp( v ) & InValue( v,s2,u )] ]
SLOT DEFINATION:
COMPOSITION:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Composition = CAR( HLD ) ⊃
∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
[IF CDR( CDR( HLD ) ) = NIL
THEN GetValue-1( u,p1 ) = GetValue-1( u,p2 )
ELSE ∃ p3. HighLevelDefn( p3 ) = CONS('Composition, CDR( CDR (HLD) ) )] &
∀ v. InValue( u,p2,v ) ⊃
Unitp( v ) & GetValue-1( v,p3 ) = GetValue-1( u,p1 )
UNIONING:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Composition = CAR( HLD ) ⊃
[∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
∀ v. InValue( u,p2,v ) ⊃ InValue( u,p1,v )] &
[IF CDR( CDR( HLD ) ) ≠ NIL
THEN ∃ p3. HighLevelDefn( p3 ) = CONS('Unioning, CDR( CDR (HLD) ) )] &
∀ v. InValue( u,p2,v ) ⊃ InValue( u,p1,v )
STARRING:
∀ p1,HLD,u. HLD = HighLevelDefn( p1 ) & Starring = CAR( HLD ) ⊃
InValue( u,p2,u ) &
∃ p2. HighLevelDefn( p2 ) = CAR (CDR ( HLD ) ) &
∀ v,v1. InValue( u,p2,v ) ⊃
Unitp( v ) & [InValue( v,p1,v1 ) ⊃ InValue( u,p1,v1 ) ]
!TO CSD.GENESERETH, CSD.SMITH 13:38 17-June
Proposition:
RLL will come with a large (and extendable) set of Simulation Structures.
The initial ("top level") SS (that is, the starting setting for the
organ,) defines each SS as a set of linguistic elements (which are the set of
LISP functions,) only some of which have a semantic interpretation. That subset
is different for each SS; as is the actual interpretation.
(Hence, RDG's RLL has defined GetValue and PutValue, whereas MRG's version makes
no effort to define these, and instead worries about True and Value.)
These functions are used to access the information in the KB;
each SS somehow states that all the other symbols of LISP are
available to the user, but does not provide these linguistic elements
with any (pre-defined) semantics.
When creating a new KB, the user may
(1) indicate which SS he wishes
(2) indicate this KB will have a new type of SS - and will proceed to
to define it (using mechanisms of the current SS.)
Questions:
1) Does this seem feasible? Is it basically what you had in mind? What would you
want to change?
2) Should each KB have exactly 1 Simulation Structure associated with it?
Is this a limitation - when might a user wish a single KB to have
more than one SS?
3) How many functions should there be for accessing the KB? I believe this
number should be small, and these functions should have a good "semantics".
Comments in general.
What's in a Language?
∂TO CSD.SMITH, CSD.GENESERETH, STT (?/80)
List of terms to be defined -- or at least have a common
meaning to those of us here:
Language
A set of words and a grammar. Note this is a-semantic.
They are inherently Linguistic entitites -- in the manner of
a grammar is. [See RWW's LS-pairs, ie Language/Structure]
Representation
A mapping between words in a language and objects,
relationships, etc. in the (some) world.
Representation is both an interpretation and a set of symbols
In this sense, language is a component of a representation
[See SIGART, p. 68-9 for defn, p.5 for illustration of difficulties]
Representation Language
Corresponds to "real world" IN NATURAL WAY -
so the pieces are easy to manipulate
Each is a scheme for constructing and augmenting
a representation, including tools for facilitating this process.
Note than a representation language IS A representation and a language.
Representational Components
Pieces used in a representation languages.
Representation Language Language
A scheme for constructing and augmenting
a representation language, including tools for facilitating same.
Note than a representation language language IS A representation language.
Linguistic
Epistemologic
(Epistemological neutrality)
Semantics
Syntax
Model
Interpretation
Frame/Schema/Unit
Slot
Proposition
Inheritance
Default
Modality
Object Centered
Function Centered
Stream Centered
"Reason maintanence" (nee "Truth maintanence")
Justification
Meta-level
Instance
Perspective/View
Self-descriptive
Self-modifiable
Specific to RLL
---------------
Slot Type
Class of Units
Typical Member
!∂07-Oct-80 0742 CSD.SMITH at SU-SCORE Re: Start of Glossary
Date: 7 Oct 1980 0736-PDT
From: CSD.SMITH at SU-SCORE
Subject: Re: Start of Glossary
To: RDG at SU-AI
In-Reply-To: Your message of 6-Oct-80 1659-PDT
RPLACA(("Truth maintenance" ...) "Reason maintenance"]
-------
Date: 27 Oct 1980 1217-PST
From: CSD.SMITH
Subject: next meeting
To: CSD.GENESERETH, CSD.SMITH, CSD.GREINER, CSD.STT, csd.bennett, JD at SU-AI,
LGC at SU-AI, CSD.CPP, RMS at SU-AI
For this fridays representation meeting the subject will be SDL and FOL.
Readings are Weyrauch's PROLEGOMENA (in recent AI Journal issue)
and Dolyle's SDL chapter (chapter 2).
Also you might think about the following questions (which I hope we can reach
a consensus on):
What is a "representation"?
What is a "theory"? Are they equivalent?
What does it mean to be an "object" or "individual"?
(If you think this question is easy, think about your desk or
office as being a quantum-mechanical wave function.)
What is the relationship between theories and contexts?
What would it mean for a theory to refer to itself?
What would it mean for a process to (have a theory of and) change itself
...etc.
Cheers. Dave.
-------
---------------
-------